package concurrent;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description: TODO 线程池
 * @Author: wzj
 * @Date: 2019/12/25 8:42
 */
public class ThreadPool {
    public static void main(String[] args) {
        ThreadPool demo = new ThreadPool();
        demo.test();
    }
    public void test(){
        /*
        核心线程数：2
        最大线程数：4
        当线程数大于核心时，多余空闲线程等待超过1分钟（时间单位TimeUnit.MINUTES）后退出
        阻塞队列长度：6

        只有线程数大于2+6（核心线程数+阻塞队列长度），即大于8时才会再新建一个线程，直到建了4个线程（最大线程数）
        就是说线程只使用核心线程数运行线程，大于核心线程数时，放入阻塞队列，直到阻塞队列满了，才会新建一个线程，
        一直到阻塞队列满了并且也达到了最大线程数，如果再有新的线程来才会执行拒绝策略（就是说最多可以接收 最大线程数+阻塞队列长度 个线程，超过之后就会执行拒绝策略）。
         */
        ThreadPoolExecutor exec=new ThreadPoolExecutor(2,4,1, TimeUnit.MINUTES, new ArrayBlockingQueue<>(6));
        try {
            for(int i=0;i<10;i++){
                TestPoolThreadRunnable thread = new TestPoolThreadRunnable(i);
                System.out.println("创建"+thread.count);
                exec.execute(thread);
            }
            exec.shutdown();
            /*try {
                while(exec.awaitTermination(10, TimeUnit.SECONDS));
            } catch (Exception e) {
                e.printStackTrace();
            }*/
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    class TestPoolThreadRunnable implements Runnable{
        private Integer count;

        public TestPoolThreadRunnable(Integer count){
            this.count = count;
        }
        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(1L);
                System.out.println(count);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
